Defer tail call ret ty equality to check_tail_calls #144915

compiler-errors · 2025-08-04T16:14:21Z

Currently the tail call signature check assumes that return types have been accounted for. However, this is not complete for several reasons.

Firstly, we were using subtyping instead of equality in the HIR typeck code:

rust/compiler/rustc_hir_typeck/src/expr.rs

Line 1096 in e1b9081

self.demand_suptype(expr.span, ret_ty, call_expr_ty);

We could fix this, but it doesn't really do much for us anyways since HIR typeck doesn't care about regions.

That means, secondly, we'd need to fix the terminator type check in MIR typeck to account for variances, since tail call terminators need to relate their arguments invariantly to account for the "signature must be equal" rule. This seems annoying.

All of this seems like a lot of work, and we already are manually checking argument equality. Let's just extend the check_tail_calls to account for mismatches in return types anyways.

r? @WaffleLapkin

rustbot · 2025-08-04T16:14:26Z

WaffleLapkin is not on the review rotation at the moment.
They may take a while to respond.

lcnr · 2025-08-05T09:24:37Z

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1931,7 +1931,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                    self.tcx(),
                    self.infcx.typing_env(self.infcx.param_env),
                ) {
-                    span_mirbug!(self, term, "call to converging function {:?} w/o dest", sig);


isn't the point here that the function does not diverge (as its return type is not uninhabited), but we don't have a dest?

as in, the comment was correct

hm... i think i see, but in that case i would call it non-diverging

lcnr · 2025-08-05T09:28:28Z

compiler/rustc_mir_build/src/check_tail_calls.rs

@@ -118,21 +118,7 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
        }

        if caller_sig.inputs_and_output != callee_sig.inputs_and_output {


please also add a test that we anonymize bound vars: for<'a> fn(&'a ()) and for<'b> fn(&'b ())

lcnr · 2025-08-05T09:30:21Z

r? lcnr

r=me after nits

WaffleLapkin · 2025-08-05T09:49:22Z

That means, secondly, we'd need to fix the terminator type check in MIR typeck to account for variances, since tail call terminators need to relate their arguments invariantly to account for the "signature must be equal" rule. This seems annoying.

That doesn't seem to track for me 🤔

The only reason we care about signature equality is that we need ABIs to match exactly, but ABIs are completely unaffected by lifetimes, so for the purpose of lifetimes we can do the same as normal call+ret.

WaffleLapkin · 2025-08-05T09:50:54Z

compiler/rustc_mir_build/src/check_tail_calls.rs

-            // FIXME(explicit_tail_calls): this currently fails for cases where opaques are used.
-            // e.g.
-            // ```
-            // fn a() -> impl Sized { become b() } // ICE
-            // fn b() -> u8 { 0 }
-            // ```
-            // we should think what is the expected behavior here.
-            // (we should probably just accept this by revealing opaques?)


Can you keep this fixme? (it doesn't ICE anymore, but doesn't work either...)

WaffleLapkin · 2025-08-05T09:52:03Z

tests/ui/explicit-tail-calls/ret-ty-hr-mismatch.stderr

+   = note: caller signature: `fn() -> for<'a> fn(&'a i32)`
+   = note: callee signature: `fn() -> fn(&i32)`


Why are we not printing 'static? This looks so confusing 😵‍💫

Because we erase regions. We could print the unerased signature, but this has nothing to do with static, and it is a preexisting issue with args.

preexisting example:

#![feature(explicit_tail_calls)] #![allow(incomplete_features)] fn foo<'a>(_: fn(&'a ())) { become bar(dummy); } fn bar(_: fn(&())) {} fn dummy(_: &()) {} fn main() {}

error: mismatched signatures --> src/main.rs:5:5 | 5 | become bar(dummy); | ^^^^^^^^^^^^^^^^^ | = note: `become` requires caller and callee to have matching signatures = note: caller signature: `fn(fn(&()))` = note: callee signature: `fn(for<'a> fn(&'a ()))`

I've opened #144957 so that we don't forget to return to this at some point

compiler-errors · 2025-08-05T11:54:43Z

That doesn't seem to track for me 🤔

The only reason we care about signature equality is that we need ABIs to match exactly, but ABIs are completely unaffected by lifetimes, so for the purpose of lifetimes we can do the same as normal call+ret.

They are affected by higher-ranked lifetimes, though, and higher-ranked subtyping is different than higher-ranked equality. So what I'm saying is that checking this the way that normal return types are checked is (theoretically) insufficient since they don't enforce return type equality, but just a subtyping relationship between the thing being returned by the callee and the thing being returned by the caller.

That being said, do we even have a case where a non-invariant arg causes a struct or something to have a different layout so that a subtyping operation would change its layout?

theemathas · 2025-08-05T11:58:05Z

A type and its subtype always has the same layout and ABI, since fn() -> Subtype can be coerced to a fn() -> Supertype without changing the machine code.

WaffleLapkin

this looks like a reasonable step. r=us with nits

WaffleLapkin · 2025-08-05T13:03:34Z

compiler/rustc_mir_build/src/check_tail_calls.rs

-            if caller_sig.output() != callee_sig.output() {
-                span_bug!(expr.span, "hir typeck should have checked the return type already");
-            }
+            self.report_arguments_mismatch(expr.span, caller_sig, callee_sig);


nit: the function should probably be renamed to report_signature_mismatch

Defer tail call ret ty equality to check_tail_calls

e42f3ae

rustbot assigned WaffleLapkin Aug 4, 2025

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Aug 4, 2025

This comment was marked as off-topic.

Sign in to view

WaffleLapkin added the F-explicit_tail_calls `#![feature(explicit_tail_calls)]` label Aug 5, 2025

WaffleLapkin mentioned this pull request Aug 5, 2025

Tracking Issue for Explicit Tail Calls #112788

Open

26 tasks

lcnr reviewed Aug 5, 2025

View reviewed changes

rustbot assigned lcnr and unassigned WaffleLapkin Aug 5, 2025

WaffleLapkin reviewed Aug 5, 2025

View reviewed changes

WaffleLapkin approved these changes Aug 5, 2025

View reviewed changes

		@@ -118,21 +118,7 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
		}

		if caller_sig.inputs_and_output != callee_sig.inputs_and_output {

		= note: caller signature: `fn() -> for<'a> fn(&'a i32)`
		= note: callee signature: `fn() -> fn(&i32)`

Defer tail call ret ty equality to check_tail_calls #144915

Are you sure you want to change the base?

Defer tail call ret ty equality to check_tail_calls #144915

Conversation

compiler-errors commented Aug 4, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rustbot commented Aug 4, 2025

Uh oh!

This comment was marked as off-topic.

This comment was marked as off-topic.

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lcnr commented Aug 5, 2025

Uh oh!

WaffleLapkin commented Aug 5, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

compiler-errors commented Aug 5, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

theemathas commented Aug 5, 2025

Uh oh!

WaffleLapkin left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

compiler-errors commented Aug 4, 2025 •

edited

Loading

compiler-errors commented Aug 5, 2025 •

edited

Loading